/*
Copyright (c) [2019年5月1日] [吴超]
[MBT_studio] is licensed under Mulan PSL v2.
You can use this software according to the terms and conditions of the Mulan PSL v2.
You may obtain a copy of Mulan PSL v2 at:
		 http://license.coscl.org.cn/MulanPSL2
THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
See the Mulan PSL v2 for more details.
*/
#include "stdafx.h"
#include "字符插座.h"
#include "节点数据声明.h"



C_路径插座::C_路径插座(std::u16string name) :C_插座基类(name, E_值类型::e_Type_路径) {
	m_Value = f_alloc_PathProp(nullptr, u"路径");
	m_Value.m_私有 = true;
}

C_路径插座::~C_路径插座() {
	f_prop_Release(m_Value);
}

void* C_路径插座::f_getData(uint8 当前插座连接线ID) {
	C_插座基类* socket = f_getLinkOutSocket(当前插座连接线ID);
	if (socket) {
		if (socket->m_Type == E_值类型::e_Type_路径) {
			return socket->f_getData(0);
		}
		else if (socket->m_Type == E_值类型::e_Type_Str) {
			
		}
	}

	return m_Value.m_Value;
}

void C_路径插座::f_setData(void* data, uint8 线程ID) {

}

std::string C_路径插座::f_构建变量代码() {
	return std::string();
}

bool C_路径插座::f_接入插座是否匹配(E_值类型 type) {
	switch (type) {
	case e_Type_路径:
	case e_Type_Str:
		return true;
	}
	return false;
}

void C_路径插座::f_读取(FILE* f) {
	C_插座基类::f_读取(f);
	f_prop_Load(m_Value, f);
}

void C_路径插座::f_写入(FILE* f) {
	C_插座基类::f_写入(f);
	f_prop_Save(m_Value, f);
}




C_字符串插座::C_字符串插座(std::u16string name) :C_插座基类(name, E_值类型::e_Type_Str) {
	m_默认 = f_alloc_StrProp(nullptr, u"文本");
	m_转换 = f_alloc_StrProp(nullptr, u"文本");

	m_Value = m_默认;
}

C_字符串插座::~C_字符串插座() {
	f_prop_Release(m_默认);
	f_prop_Release(m_转换);
}

void* C_字符串插座::f_getData(uint8 当前插座连接线ID) {
	C_插座基类* socket = f_getLinkOutSocket(当前插座连接线ID);
	if (socket) {
		if (socket->m_Type == E_值类型::e_Type_Str) {
			return socket->f_getData(0);
		}
		else if (socket->m_Type == E_值类型::e_Type_路径) {

		}

		m_Value = m_转换;
	}
	else if (!m_映射指针) {
		m_Value = m_默认;
	}

	return &m_Value;
}

void C_字符串插座::f_setData(void* data, uint8 线程ID) {
	C_插座基类::f_setData(data);
	if (data) {
		m_Value = *(S_Props*)data;
	}
}

std::string C_字符串插座::f_构建变量代码(int32 loc) {
	C_插座基类* socket = f_getLinkOutSocket(loc);

	if (socket) {
		if (socket->m_Type == E_值类型::e_Type_Str || socket->m_Type == E_值类型::e_Type_LineText) {
			m_Code = socket->f_getCode(loc);
			return "";
		}
		this;
	}
	else {
		C_插座基类::f_构建变量代码(loc);
		return "";
	}

	return std::string();
}

bool C_字符串插座::f_接入插座是否匹配(E_值类型 type) {
	switch (type) {
	case e_Type_路径:
	case e_Type_Str:
		return true;
	}
	return false;
}

void C_字符串插座::f_读取(FILE* f) {
	C_插座基类::f_读取(f);
	f_prop_Load(m_Value, f);
}

void C_字符串插座::f_写入(FILE* f) {
	C_插座基类::f_写入(f);
	f_prop_Save(m_Value, f);
}






//C_字符串插座::C_字符串插座(std::wstring name) :C_插座基类(name, E_值类型::e_Type_Str) {
//	m_Value = f_alloc_StrProp(nullptr, L"文本");
//}
//
//C_字符串插座::~C_字符串插座() {
//}
//
//void* C_字符串插座::f_getData(uint8 当前插座连接线ID) {
//	C_插座基类* socket = f_getLinkOutSocket(当前插座连接线ID);
//	if (socket) {
//		if (socket->m_Type == E_值类型::e_Type_Str) {
//			return socket->f_getData(0);
//		}
//		else if (socket->m_Type == E_值类型::e_Type_路径) {
//
//		}
//	}
//
//	return m_Value.m_Value;
//}
//
//void C_字符串插座::f_setData(void* data, uint8 线程ID) {
//
//}
//
//std::string C_字符串插座::f_构建变量代码() {
//	return std::string();
//}
//
//bool C_字符串插座::f_接入插座是否匹配(E_值类型 type) {
//	switch (type) {
//		case e_Type_路径:
//		case e_Type_Str:
//			return true;
//	}
//	return false;
//}
//
//void C_字符串插座::f_读取(FILE* f) {
//	C_插座基类::f_读取(f);
//	f_prop_Load(m_Value, f);
//}
//
//void C_字符串插座::f_写入(FILE* f) {
//	C_插座基类::f_写入(f);
//	f_prop_Save(m_Value, f);
//}




C_字体插座::C_字体插座(std::u16string name) :C_插座基类(name, E_值类型::e_Type_字体) {
	m_默认 = {};
	m_转换 = {};
	m_Value = &m_默认;
}

C_字体插座::~C_字体插座() {
}

void* C_字体插座::f_getData(uint8 当前插座连接线ID) {
	C_插座基类* socket = f_getLinkOutSocket(当前插座连接线ID);
	if (socket) {
		if (socket->m_Type == E_值类型::e_Type_字体) {
			return socket->f_getData(0);
		}
		else if (socket->m_Type == E_值类型::e_Type_Str) {
			
		}
		else if (socket->m_Type == E_值类型::e_Type_路径) {

		}

		m_Value = &m_转换;
	}
	else if (!m_映射指针) {
		m_Value = &m_默认;
	}
	return m_Value;
}

void C_字体插座::f_setData(void* data, uint8 线程ID) {
	m_Value = ((S_字体*)data);
	m_映射指针 = true;
}

std::string C_字体插座::f_构建变量代码(int32 loc) {
	C_插座基类* socket = f_getLinkOutSocket(loc);

	std::string code;
	if (socket) {
		if (socket->m_Type == E_值类型::e_Type_字体) {
			m_Code = socket->f_getCode(loc);
			return "";
		}
	}
	else {
		C_插座基类::f_构建变量代码(loc);
		return "";
	}

	return code;
}

bool C_字体插座::f_接入插座是否匹配(E_值类型 type) {
	switch (type) {
		case E_值类型::e_Type_字体:
		case e_Type_路径:
		case e_Type_Str:
			return true;
	}
	return false;
}

void C_字体插座::f_读取(FILE* f) {
	C_插座基类::f_读取(f);
	S_文件块 文件块 = f_file_读取文件块(f);
	if (文件块.m_块类型 == E_节点工程文件块类型::e_工程文件块_节点实例属性) {
		const uint8* 下一次读取数据指针 = 文件块.m_data;
		if (f_file_版本对比(文件块, S_引擎配置::g_低版本号_0, S_引擎配置::g_文件版本号)) {
			//下一次读取数据指针 = f_prop_Load(m_字符纹理表, 下一次读取数据指针);
		}
	}
	free(文件块.m_data);
}

void C_字体插座::f_写入(FILE* f) {
	C_插座基类::f_写入(f);
	auto 文件块 = f_文件块_创建(E_节点工程文件块类型::e_工程文件块_节点实例属性, S_引擎配置::g_文件版本号);
	S_UI8Array* 块 = (S_UI8Array*)f_core_array_new(0, sizeof(uint8));
	//f_prop_Save(m_字符纹理表, 块);
	f_file_保存文件块(f, 文件块, 块);
}





C_字符串数组插座::C_字符串数组插座(std::u16string name) :C_插座基类(name, E_值类型::e_Type_LineStr1D) {
	m_默认 = (S_StrArray*)f_core_array_new(0, sizeof(S_属性*));
	m_转换 = (S_StrArray*)f_core_array_new(0, sizeof(S_属性*));
	m_Value = m_默认;
}

C_字符串数组插座::~C_字符串数组插座() {
	f_core_array_free((S_Array*)m_默认);
	f_core_array_free((S_Array*)m_转换);
}

void* C_字符串数组插座::f_getData(uint8 当前插座连接线ID) {
	C_插座基类* socket = f_getLinkOutSocket(当前插座连接线ID);
	if (socket) {
		if (socket->m_Type == E_值类型::e_Type_LineStr1D) {
			return socket->f_getData(0);
		}
		else if (socket->m_Type == E_值类型::e_Type_Str) {
			f_core_array_resize((S_Array*)m_转换, 1);
			m_转换->ptr_userData[0] = (S_Props*)f_prop_alloc_Str();

			f_prop_LineStr(*m_转换->ptr_userData[0]) = f_prop_LineStr(DEF_字符串插座数据(socket));
		}
		//else if (socket->m_Type == E_值类型::e_Type_路径) {
		//	auto& str = DEF_字符串插座数据(socket1Out);
		//
		//	f_core_array_resize((S_Array*)m_转换, 1);
		//	m_转换->ptr_userData[0] = (S_Props*)f_prop_alloc_Str();
		//}

		m_Value = m_转换;
	}
	else if (!m_映射指针) {
		m_Value = m_默认;
	}
	return m_Value;
}

void C_字符串数组插座::f_setData(void* data, uint8 线程ID) {
	C_插座基类::f_setData(data);
	if (data) {
		m_Value = ((S_StrArray*)data);
		m_映射指针 = true;
	}
	else {
		m_映射指针 = false;
	}
}

std::string C_字符串数组插座::f_构建变量代码(int32 loc) {
	C_插座基类* socket = f_getLinkOutSocket(loc);

	std::string code;
	if (socket) {
		if (socket->m_Type == E_值类型::e_Type_LineStr1D) {
			m_Code = socket->f_getCode(loc);
			return "";
		}
	}
	else {
		C_插座基类::f_构建变量代码(loc);
		return "";
	}

	return code;
}

bool C_字符串数组插座::f_接入插座是否匹配(E_值类型 type) {
	switch (type) {
		case E_值类型::e_Type_LineStr1D:
		case E_值类型::e_Type_Str:
		//case E_值类型::e_Type_路径:
			return true;
	}
	return false;
}

void C_字符串数组插座::f_读取(FILE* f) {
	C_插座基类::f_读取(f);
	S_文件块 文件块 = f_file_读取文件块(f);
	if (文件块.m_块类型 == E_节点工程文件块类型::e_工程文件块_节点实例属性) {
		const uint8* 下一次读取数据指针 = 文件块.m_data;
		if (f_file_版本对比(文件块, S_引擎配置::g_低版本号_0, S_引擎配置::g_文件版本号)) {
			//下一次读取数据指针 = f_prop_Load(m_字符纹理表, 下一次读取数据指针);
		}
	}
	free(文件块.m_data);
}

void C_字符串数组插座::f_写入(FILE* f) {
	C_插座基类::f_写入(f);
	auto 文件块 = f_文件块_创建(E_节点工程文件块类型::e_工程文件块_节点实例属性, S_引擎配置::g_文件版本号);
	S_UI8Array* 块 = (S_UI8Array*)f_core_array_new(0, sizeof(uint8));
	//f_prop_Save(m_字符纹理表, 块);
	f_file_保存文件块(f, 文件块, 块);
}




